<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML
><HEAD
><TITLE
>Operators</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
REV="MADE"
HREF="mailto:pgsql-docs@postgresql.org"><LINK
REL="HOME"
TITLE="PostgreSQL 9.1.2 Documentation"
HREF="index.html"><LINK
REL="UP"
TITLE="Type Conversion"
HREF="typeconv.html"><LINK
REL="PREVIOUS"
TITLE="Overview"
HREF="typeconv-overview.html"><LINK
REL="NEXT"
TITLE="Functions"
HREF="typeconv-func.html"><LINK
REL="STYLESHEET"
TYPE="text/css"
HREF="stylesheet.css"><META
HTTP-EQUIV="Content-Type"
CONTENT="text/html; charset=ISO-8859-1"><META
NAME="creation"
CONTENT="2011-12-01T22:07:59"></HEAD
><BODY
CLASS="SECT1"
><DIV
CLASS="NAVHEADER"
><TABLE
SUMMARY="Header navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TH
COLSPAN="5"
ALIGN="center"
VALIGN="bottom"
><A
HREF="index.html"
>PostgreSQL 9.1.2 Documentation</A
></TH
></TR
><TR
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="top"
><A
TITLE="Overview"
HREF="typeconv-overview.html"
ACCESSKEY="P"
>Prev</A
></TD
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="top"
><A
HREF="typeconv.html"
ACCESSKEY="U"
>Up</A
></TD
><TD
WIDTH="60%"
ALIGN="center"
VALIGN="bottom"
>Chapter 10. Type Conversion</TD
><TD
WIDTH="20%"
ALIGN="right"
VALIGN="top"
><A
TITLE="Functions"
HREF="typeconv-func.html"
ACCESSKEY="N"
>Next</A
></TD
></TR
></TABLE
><HR
ALIGN="LEFT"
WIDTH="100%"></DIV
><DIV
CLASS="SECT1"
><H1
CLASS="SECT1"
><A
NAME="TYPECONV-OPER"
>10.2. Operators</A
></H1
><P
>   The specific operator that is referenced by an operator expression
   is determined using the following procedure.
   Note that this procedure is indirectly affected
   by the precedence of the involved operators, since that will determine
   which sub-expressions are taken to be the inputs of which operators.
   See <A
HREF="sql-syntax-lexical.html#SQL-PRECEDENCE"
>Section 4.1.6</A
> for more information.
  </P
><DIV
CLASS="PROCEDURE"
><P
><B
>Operator Type Resolution</B
></P
><OL
TYPE="1"
><LI
CLASS="STEP"
><P
>Select the operators to be considered from the
<CODE
CLASS="CLASSNAME"
>pg_operator</CODE
> system catalog.  If a non-schema-qualified
operator name was used (the usual case), the operators
considered are those with the matching name and argument count that are
visible in the current search path (see <A
HREF="ddl-schemas.html#DDL-SCHEMAS-PATH"
>Section 5.7.3</A
>).
If a qualified operator name was given, only operators in the specified
schema are considered.</P
><OL
CLASS="SUBSTEPS"
TYPE="a"
><LI
CLASS="STEP"
><P
>If the search path finds multiple operators with identical argument types,
only the one appearing earliest in the path is considered.  Operators with
different argument types are considered on an equal footing regardless of
search path position.</P
></LI
></OL
></LI
><LI
CLASS="STEP"
><P
>Check for an operator accepting exactly the input argument types.
If one exists (there can be only one exact match in the set of
operators considered), use it.</P
><OL
CLASS="SUBSTEPS"
TYPE="a"
><LI
CLASS="STEP"
><P
>If one argument of a binary operator invocation is of the <TT
CLASS="TYPE"
>unknown</TT
> type,
then assume it is the same type as the other argument for this check.
Invocations involving two <TT
CLASS="TYPE"
>unknown</TT
> inputs, or a unary operator
with an <TT
CLASS="TYPE"
>unknown</TT
> input, will never find a match at this step.</P
></LI
></OL
></LI
><LI
CLASS="STEP"
><P
>Look for the best match.</P
><OL
CLASS="SUBSTEPS"
TYPE="a"
><LI
CLASS="STEP"
><P
>Discard candidate operators for which the input types do not match
and cannot be converted (using an implicit conversion) to match.
<TT
CLASS="TYPE"
>unknown</TT
> literals are
assumed to be convertible to anything for this purpose.  If only one
candidate remains, use it; else continue to the next step.</P
></LI
><LI
CLASS="STEP"
><P
>Run through all candidates and keep those with the most exact matches
on input types.  (Domains are considered the same as their base type
for this purpose.)  Keep all candidates if none have exact matches.
If only one candidate remains, use it; else continue to the next step.</P
></LI
><LI
CLASS="STEP"
><P
>Run through all candidates and keep those that accept preferred types (of the
input data type's type category) at the most positions where type conversion
will be required.
Keep all candidates if none accept preferred types.
If only one candidate remains, use it; else continue to the next step.</P
></LI
><LI
CLASS="STEP"
><P
>If any input arguments are <TT
CLASS="TYPE"
>unknown</TT
>, check the type
categories accepted at those argument positions by the remaining
candidates.  At each position, select the <TT
CLASS="TYPE"
>string</TT
> category
if any
candidate accepts that category.  (This bias towards string is appropriate
since an unknown-type literal looks like a string.) Otherwise, if
all the remaining candidates accept the same type category, select that
category; otherwise fail because the correct choice cannot be deduced
without more clues.  Now discard
candidates that do not accept the selected type category.  Furthermore,
if any candidate accepts a preferred type in that category,
discard candidates that accept non-preferred types for that argument.</P
></LI
><LI
CLASS="STEP"
><P
>If only one candidate remains, use it.  If no candidate or more than one
candidate remains,
then fail.</P
></LI
></OL
></LI
></OL
></DIV
><P
>Some examples follow.</P
><DIV
CLASS="EXAMPLE"
><A
NAME="AEN19923"
></A
><P
><B
>Example 10-1. Factorial Operator Type Resolution</B
></P
><P
>There is only one factorial operator (postfix <TT
CLASS="LITERAL"
>!</TT
>)
defined in the standard catalog, and it takes an argument of type
<TT
CLASS="TYPE"
>bigint</TT
>.
The scanner assigns an initial type of <TT
CLASS="TYPE"
>integer</TT
> to the argument
in this query expression:
</P><PRE
CLASS="SCREEN"
>SELECT 40 ! AS "40 factorial";

                   40 factorial
--------------------------------------------------
 815915283247897734345611269596115894272000000000
(1 row)</PRE
><P>

So the parser does a type conversion on the operand and the query
is equivalent to:

</P><PRE
CLASS="SCREEN"
>SELECT CAST(40 AS bigint) ! AS "40 factorial";</PRE
><P></P
></DIV
><DIV
CLASS="EXAMPLE"
><A
NAME="AEN19931"
></A
><P
><B
>Example 10-2. String Concatenation Operator Type Resolution</B
></P
><P
>A string-like syntax is used for working with string types and for
working with complex extension types.
Strings with unspecified type are matched with likely operator candidates.</P
><P
>An example with one unspecified argument:
</P><PRE
CLASS="SCREEN"
>SELECT text 'abc' || 'def' AS "text and unknown";

 text and unknown
------------------
 abcdef
(1 row)</PRE
><P></P
><P
>In this case the parser looks to see if there is an operator taking <TT
CLASS="TYPE"
>text</TT
>
for both arguments. Since there is, it assumes that the second argument should
be interpreted as type <TT
CLASS="TYPE"
>text</TT
>.</P
><P
>Here is a concatenation on unspecified types:
</P><PRE
CLASS="SCREEN"
>SELECT 'abc' || 'def' AS "unspecified";

 unspecified
-------------
 abcdef
(1 row)</PRE
><P></P
><P
>In this case there is no initial hint for which type to use, since no types
are specified in the query. So, the parser looks for all candidate operators
and finds that there are candidates accepting both string-category and
bit-string-category inputs.  Since string category is preferred when available,
that category is selected, and then the
preferred type for strings, <TT
CLASS="TYPE"
>text</TT
>, is used as the specific
type to resolve the unknown literals as.</P
></DIV
><DIV
CLASS="EXAMPLE"
><A
NAME="AEN19943"
></A
><P
><B
>Example 10-3. Absolute-Value and Negation Operator Type Resolution</B
></P
><P
>The <SPAN
CLASS="PRODUCTNAME"
>PostgreSQL</SPAN
> operator catalog has several
entries for the prefix operator <TT
CLASS="LITERAL"
>@</TT
>, all of which implement
absolute-value operations for various numeric data types.  One of these
entries is for type <TT
CLASS="TYPE"
>float8</TT
>, which is the preferred type in
the numeric category.  Therefore, <SPAN
CLASS="PRODUCTNAME"
>PostgreSQL</SPAN
>
will use that entry when faced with an <TT
CLASS="TYPE"
>unknown</TT
> input:
</P><PRE
CLASS="SCREEN"
>SELECT @ '-4.5' AS "abs";
 abs
-----
 4.5
(1 row)</PRE
><P>
Here the system has implicitly resolved the unknown-type literal as type
<TT
CLASS="TYPE"
>float8</TT
> before applying the chosen operator.  We can verify that
<TT
CLASS="TYPE"
>float8</TT
> and not some other type was used:
</P><PRE
CLASS="SCREEN"
>SELECT @ '-4.5e500' AS "abs";

ERROR:  "-4.5e500" is out of range for type double precision</PRE
><P></P
><P
>On the other hand, the prefix operator <TT
CLASS="LITERAL"
>~</TT
> (bitwise negation)
is defined only for integer data types, not for <TT
CLASS="TYPE"
>float8</TT
>.  So, if we
try a similar case with <TT
CLASS="LITERAL"
>~</TT
>, we get:
</P><PRE
CLASS="SCREEN"
>SELECT ~ '20' AS "negation";

ERROR:  operator is not unique: ~ "unknown"
HINT:  Could not choose a best candidate operator. You might need to add
explicit type casts.</PRE
><P>
This happens because the system cannot decide which of the several
possible <TT
CLASS="LITERAL"
>~</TT
> operators should be preferred.  We can help
it out with an explicit cast:
</P><PRE
CLASS="SCREEN"
>SELECT ~ CAST('20' AS int8) AS "negation";

 negation
----------
      -21
(1 row)</PRE
><P></P
></DIV
></DIV
><DIV
CLASS="NAVFOOTER"
><HR
ALIGN="LEFT"
WIDTH="100%"><TABLE
SUMMARY="Footer navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
><A
HREF="typeconv-overview.html"
ACCESSKEY="P"
>Prev</A
></TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="index.html"
ACCESSKEY="H"
>Home</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
><A
HREF="typeconv-func.html"
ACCESSKEY="N"
>Next</A
></TD
></TR
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
>Overview</TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="typeconv.html"
ACCESSKEY="U"
>Up</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
>Functions</TD
></TR
></TABLE
></DIV
></BODY
></HTML
>